home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / mint / lib / mntlib44.zoo / mntlib / scanf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-01  |  10.1 KB  |  553 lines
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include <string.h>
  4. #include <stdarg.h>
  5. #include "lib.h"
  6.  
  7. /*
  8.  * %efg were loosing big time
  9.  *    fixed  ++jrb
  10.  * all floating conversion now done by atof. much is gained by this.
  11.  *    ++jrb
  12.  *
  13.  * hacked to use stdarg by bm
  14.  */
  15.  
  16. #ifndef __NO_FLOAT__
  17. #define FLOATS 1
  18. #endif
  19.  
  20. #ifndef TRUE
  21. #define TRUE  1
  22. #define FALSE 0
  23. #endif
  24.  
  25. #define    skip() \
  26.   while (isspace(c)) { charcnt++; c = (*get)(ip); if (c == EOF) goto done; }
  27. #define TEN_MUL(X)    ((((X) << 2) + (X)) << 1)
  28.  
  29. #if FLOATS
  30. /* fp scan actions */
  31. #define F_NADA    0    /* just change state */
  32. #define F_SIGN    1    /* set sign */
  33. #define F_ESIGN    2    /* set exponent's sign */
  34. #define F_INT    3    /* adjust integer part */
  35. #define F_FRAC    4    /* adjust fraction part */
  36. #define F_EXP    5    /* adjust exponent part */
  37. #define F_QUIT    6
  38.  
  39. #define NSTATE    8
  40. #define FS_INIT        0    /* initial state */
  41. #define FS_SIGNED    1    /* saw sign */
  42. #define FS_DIGS        2    /* saw digits, no . */
  43. #define FS_DOT        3    /* saw ., no digits */
  44. #define FS_DD        4    /* saw digits and . */
  45. #define FS_E        5    /* saw 'e' */
  46. #define FS_ESIGN    6    /* saw exp's sign */
  47. #define FS_EDIGS    7    /* saw exp's digits */
  48.  
  49. #define FC_DIG        0
  50. #define FC_DOT        1
  51. #define FC_E        2
  52. #define FC_SIGN        3
  53.  
  54. /* given transition,state do what action? */
  55. static const int fp_do[][NSTATE] = {
  56. {F_INT,F_INT,F_INT,
  57.      F_FRAC,F_FRAC,
  58.      F_EXP,F_EXP,F_EXP},    /* see digit */
  59. {F_NADA,F_NADA,F_NADA,
  60.      F_QUIT,F_QUIT,F_QUIT,F_QUIT,F_QUIT},    /* see '.' */
  61. {F_QUIT,F_QUIT,
  62.      F_NADA,F_QUIT,F_NADA,
  63.      F_QUIT,F_QUIT,F_QUIT},    /* see e/E */
  64. {F_SIGN,F_QUIT,F_QUIT,F_QUIT,F_QUIT,
  65.      F_ESIGN,F_QUIT,F_QUIT},    /* see sign */
  66. };
  67. /* given transition,state what is new state? */
  68. static const int fp_ns[][NSTATE] = {
  69. {FS_DIGS,FS_DIGS,FS_DIGS,
  70.      FS_DD,FS_DD,
  71.      FS_EDIGS,FS_EDIGS,FS_EDIGS},    /* see digit */
  72. {FS_DOT,FS_DOT,FS_DD,
  73.  },    /* see '.' */
  74. {0,0,
  75.      FS_E,0,FS_E,
  76.  },    /* see e/E */
  77. {FS_SIGNED,0,0,0,0,
  78.      FS_ESIGN,0,0},    /* see sign */
  79. };
  80. /* which states are valid terminators? */
  81. static const int fp_sval[NSTATE] = {
  82.     0,0,1,0,1,1,1,1
  83. };
  84. #endif
  85.  
  86. #ifdef __STDC__
  87. int _scanf(register FILE *ip, int (*get)(FILE *),
  88.  int (*unget)(int, FILE *), const char *_fmt, va_list args)
  89. #else
  90. int
  91. _scanf(ip, get, unget, _fmt, args)
  92. FILE *ip;
  93. int (*get) __PROTO((FILE *));
  94. int (*unget) __PROTO((int, FILE *));
  95. const char *_fmt;
  96. char **args;
  97. #endif
  98. {
  99.     register long n;
  100.     register int c, width, lval, sval, cnt = 0, charcnt = 1;
  101. #if defined (PRINTF_LONGLONG) || defined (__STDC__)
  102.     register int llval = 0;
  103. #endif
  104. #ifdef PRINTF_LONGLONG
  105.     register long long lln;
  106. #endif
  107.     int store, neg, base, endnull, c2;
  108.     register unsigned char *p = 0;
  109.     const unsigned char *fmt = (const unsigned char *) _fmt;
  110.     char delim[256], *q;
  111. #if FLOATS
  112.     double fx;
  113.     char fbuf[128], *fbp;
  114.     int fstate, trans;
  115.     extern double atof __PROTO((const char *));
  116. #endif
  117.  
  118.     c = (*get)(ip);
  119.     while (*fmt)
  120.     {
  121.     if (*fmt == '%')
  122.     {
  123.         width    = -1;
  124.         lval    = FALSE;
  125. #if defined (PRINTF_LONGLONG) || defined (__STDC__)
  126.         llval    = FALSE;
  127. #endif
  128.         sval    = FALSE;
  129.         store    = TRUE;
  130.  
  131.         if (*++fmt == '*')
  132.         {
  133.         store = FALSE;
  134.         ++fmt;
  135.         }
  136.  
  137.         if (isdigit (*fmt))        /* width digit(s) */
  138.           {
  139.         width = *fmt++ - '0';
  140.         while (isdigit (*fmt))
  141.           width = TEN_MUL (width) + *fmt++ - '0';
  142.           }
  143.  
  144.       fmtnxt:
  145.         switch(*fmt++)
  146.         {
  147.           case 'l':    /* long data */
  148. #ifdef PRINTF_LONGLONG
  149.         if (lval)
  150.             llval = TRUE;
  151. #endif
  152.         lval = TRUE;
  153.         goto fmtnxt;
  154.  
  155. #ifdef __STDC__
  156.           case 'L': /* long double */
  157.         llval = TRUE;
  158.         goto fmtnxt;
  159. #endif
  160.  
  161.           case 'h':    /* short data (for compatibility) */
  162.         sval = TRUE;
  163.         goto fmtnxt;
  164.  
  165.           case 'i':    /* any-base numeric */
  166.         base = 0;
  167.         neg = -1;
  168.         goto numfmt;
  169.  
  170.           case 'b':    /* unsigned binary, non-standard */
  171.           case 'B': /* non-standard */
  172.         base = 2;
  173.         neg = 0;
  174.         goto numfmt;
  175.  
  176.           case 'o':    /* unsigned octal */
  177.           case 'O': /* non-standard */
  178.         base = 8;
  179.         neg = 0;
  180.         goto numfmt;
  181.  
  182.           case 'p': /* pointer */
  183.         lval = TRUE;
  184. #ifdef PRINTF_LONGLONG
  185.         llval = FALSE;
  186. #endif
  187.         /* fall through */
  188.  
  189.           case 'x':    /* unsigned hexadecimal */
  190.           case 'X': /* non-standard */
  191.         base = 16;
  192.         neg = 0;
  193.         goto numfmt;
  194.  
  195.           case 'd':    /* SIGNED decimal */
  196.           case 'D': /* non-standard */
  197.         base = 10;
  198.         neg = -1;
  199.         goto numfmt;
  200.  
  201.           case 'u':    /* unsigned decimal */
  202.           case 'U': /* non-standard */
  203.         base = 10;
  204.         neg = 0;
  205.           numfmt:
  206.         skip();
  207.         memset (delim, -1, sizeof (delim));
  208.         if (isupper(fmt[-1])) {
  209.             /* non-standard */
  210. #ifdef PRINTF_LONGLONG
  211.             if (lval) llval = TRUE;
  212. #endif
  213.             lval = TRUE;
  214.         }
  215.         n = 0;
  216. #ifdef PRINTF_LONGLONG
  217.         lln = 0;
  218. #endif
  219.         if (width == 0)
  220.           goto savnum;
  221.         if (!base)
  222.         {
  223.             if (c == '%') /* non-standard */
  224.             {
  225.             base = 2;
  226.             neg = 0;
  227.             goto skip1;
  228.             }
  229.             else if (c == '0')
  230.             {
  231.             if (--width == 0)
  232.               goto savnum;
  233.             charcnt++;
  234.             c = (*get)(ip);
  235.             if (c == EOF)
  236.                 goto savnum;
  237.             if ((c != 'x')
  238.                 && (c != 'X'))
  239.             {
  240.                 base = 8;
  241.                 neg = 0;
  242.                 for (c2 = 0; c2 < 8; c2++)
  243.                   delim[c2 + '0'] = c2;
  244.                 goto zeroin;
  245.             }
  246.             base = 16;
  247.             neg = 0;
  248.             goto skip1;
  249.             }
  250.             else
  251.               base = 10;
  252.         }
  253.  
  254.         /* Check for 0x prefix */
  255.         if (base == 16 && c == '0')
  256.           {
  257.             if (--width == 0)
  258.               goto savnum;
  259.             charcnt++;
  260.             c = (*get) (ip);
  261.             if (c == EOF)
  262.               goto savnum;
  263.             if (c == 'x' || c == 'X')
  264.               goto skip1;
  265.             /* else unget the character, it may already be a
  266.                        non-digit and the number would be rejected */
  267.             charcnt--;
  268.             (*unget) (c, ip);
  269.             c = '0';
  270.           }
  271.         else if (neg == -1)
  272.           {
  273.             neg = c == '-';
  274.             if (neg || c == '+')
  275.               {
  276.               skip1:
  277.             if (--width == 0)
  278.               goto done;
  279.             charcnt++;
  280.             c = (*get)(ip);
  281.             if (c == EOF)
  282.               goto done;
  283.               }
  284.           }
  285.  
  286.         /* delim[c] -> value of c or -1 */
  287.         p = (unsigned char *) "FEDCBAfedcba9876543210";
  288.         q = "\17\16\15\14\13\12\17\16\15\14\13\12\11\10\7\6\5\4\3\2\1\0";
  289.         if (base < 16)
  290.           {
  291.             /* skip invalid digits */
  292.             p += 22 - base;
  293.             q += 22 - base;
  294.           }
  295.         while (*p)
  296.           delim[*p++] = *q++;
  297.  
  298.         if (delim[c] == (char) -1)
  299.           goto done;
  300.  
  301.         while (width--)
  302.         {
  303. #ifdef PRINTF_LONGLONG
  304.             if (llval)
  305.             lln = (lln * base) + delim[c];
  306.             else
  307. #endif
  308.             n = (n * base) + delim[c];
  309.             charcnt++;
  310.             c = (*get)(ip);
  311.             if (c == EOF)
  312.               break;
  313.           zeroin:
  314.             if (delim[c] == (char) -1)
  315.               break;
  316.         }
  317.           savnum:
  318.         if (store)
  319.         {
  320. #ifdef __STDC__
  321.             p = va_arg(args, void *);
  322. #else
  323.             p = ((unsigned char *) *args);
  324. #endif
  325. #ifdef PRINTF_LONGLONG
  326.             if (llval)
  327.             {
  328.             if (neg)
  329.                 lln=-lln;
  330.             *((long long*) p) = lln;
  331.             }
  332.             else
  333. #endif
  334.             {
  335.             if (neg)
  336.                 n = -n;
  337.             if (lval)
  338.                 *((long*) p) = n;
  339.             else if (sval)
  340.                 *((short *) p) = (short) n;
  341.             else
  342.                 *((int *) p) = (int) n;
  343.             ++cnt;
  344.             }
  345.         }
  346.         break;
  347.  
  348. #if FLOATS
  349.           case 'E': /* non-standard */
  350.           case 'F':
  351.           case 'G':
  352.         lval = TRUE;
  353.         /* fall through */
  354.  
  355.           case 'e':    /* float */
  356.           case 'f':
  357.           case 'g':
  358.         skip();
  359.  
  360.         memset (delim, -1, sizeof (delim));
  361.         for (c2 = '0'; c2 <= '9'; c2++)
  362.           delim[c2] = FC_DIG;
  363.         delim['.'] = FC_DOT;
  364.         delim['+'] = delim['-'] = FC_SIGN;
  365.         delim['e'] = delim['E'] = FC_E;
  366.  
  367.         fstate = FS_INIT;
  368.         fbp = fbuf;
  369.         while (c != EOF && width--) {
  370.             trans = delim[c];
  371.             if (trans == (char) -1)
  372.               break;
  373.             if (fbp - fbuf + 1 < sizeof (fbuf))
  374.               *fbp++ = c;
  375.  
  376.             if (fp_do[trans][fstate] == F_QUIT)
  377.             break;
  378.             fstate = fp_ns[trans][fstate];
  379.             charcnt++;
  380.             c = (*get)(ip);
  381.         }
  382.  
  383.         *fbp = '\0';
  384.         if (!fp_sval[fstate])
  385.             goto done;
  386.         if (store) {
  387.             fx = (*fbuf == '\0') ? 0.0 : atof(fbuf);
  388. #ifdef __STDC__
  389.             p = va_arg(args, void *);
  390. #else
  391.             p = (unsigned char *) *args;
  392. #endif
  393. #ifdef __STDC__
  394.             /* partial support for long double */
  395. #ifdef __M68881__   /* currently only with m68881 */
  396.             if (llval)
  397.               *(long double *) p = (long double) fx;
  398.             else
  399. #endif
  400. #endif
  401.             if (lval)
  402.             *((double *) p) = fx;
  403.             else
  404.             *((float *) p) = (float)fx;
  405.             ++cnt;
  406.         }
  407.         break;
  408. #endif
  409.  
  410.           case 'n':
  411.         if (store) {
  412. #ifdef __STDC__
  413.           p = va_arg(args, void *);
  414. #else
  415.           p = (unsigned char *) *args;
  416. #endif
  417.           /* Compensate for lookahead */
  418.           *((int *) p) = charcnt - 1;
  419.         }
  420.         break;
  421.  
  422.           case 'c':    /* character data */
  423.         if (width == -1)
  424.           width = 1;
  425.         endnull    = FALSE;
  426.         memset (delim, 0, sizeof (delim));
  427.         if (c == EOF)
  428.           goto done;
  429.         goto strproc;
  430.  
  431.           case '[':    /* string w/ delimiter set */
  432.         endnull    = TRUE;
  433.  
  434.         /* get delimiters */
  435.         neg = FALSE;
  436.         if (*fmt == '^')
  437.           {
  438.             fmt++;
  439.             neg = TRUE;
  440.           }
  441.  
  442.         memset (delim, !neg, sizeof (delim));
  443.  
  444.         if ((*fmt == ']') || (*fmt == '-'))
  445.         {
  446.             delim[*fmt++] = neg;
  447.         }
  448.  
  449.         while (c2 = *fmt++, c2 != ']')
  450.         {
  451.             if (c2 == '\0')
  452.               break;
  453.             if (*fmt == '-' && fmt[1] && fmt[1] != ']')
  454.               {
  455.             while (c2 <= fmt[1])
  456.               delim[c2++] = neg;
  457.             fmt += 2;
  458.               }
  459.             else
  460.               delim[c2] = neg;
  461.         }
  462.  
  463.         goto strproc;
  464.  
  465.           case 's':    /* string data */
  466.         skip();
  467.         memset (delim, 0, sizeof (delim));
  468.         delim['\t'] = 1;
  469.         delim['\n'] = 1;
  470.         delim['\v'] = 1;
  471.         delim['\f'] = 1;
  472.         delim['\r'] = 1;
  473.         delim[' '] = 1;
  474.         endnull    = TRUE;
  475.           strproc:
  476.         /* process string */
  477. #ifdef __STDC__
  478.         if (store)
  479.             p = va_arg(args, void *);
  480. #else
  481.         p = ((unsigned char *) *args);
  482. #endif
  483.  
  484.         /* if the 1st char fails, match fails */
  485.         if (width)
  486.         {
  487.             if (c == EOF || delim[c])
  488.             {
  489.             if (endnull)
  490.                 if (store)
  491.                     *p = '\0';
  492.             goto done;
  493.             }
  494.         }
  495.  
  496.         for (;;) /* FOREVER */
  497.         {
  498.             if (store)
  499.             *p++ = c;
  500.             charcnt++;
  501.             c = (*get)(ip);
  502.             if (c == EOF || --width == 0)
  503.             break;
  504.             if (delim[c])
  505.             break;
  506.         }
  507.  
  508.         if (store)
  509.         {
  510.             if (endnull)
  511.             *p = '\0';
  512.             ++cnt;
  513.         }
  514.         break;
  515.  
  516.           case '%':
  517.         --fmt;
  518.         goto cmatch;
  519.  
  520.           default:
  521.         goto done;
  522.         }
  523.     }
  524.     else if (isspace(*fmt))        /* skip whitespace */
  525.     {
  526.         fmt++;
  527.         skip();
  528.     }
  529.     else
  530.     {            /* normal match char */
  531.       cmatch:
  532.         if (c != *fmt++)
  533.           goto done;
  534.         charcnt++;
  535.         c = (*get)(ip);
  536.     }
  537.  
  538. #ifdef __STDC__
  539.     /* nothing to do */
  540. #else
  541.     if (store)
  542.         args++;
  543. #endif
  544.     }
  545.  
  546.   done:                        /* end of scan */
  547.     if (c != EOF)
  548.       (*unget) (c, ip);
  549.     if (c == EOF && cnt == 0)
  550.     return(EOF);
  551.     return(cnt);
  552. }
  553.